home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 2 / CU Amiga Magazine's Super CD-ROM 02 (1996)(EMAP Images)(GB)[!][issue 1996-04].iso / magazine / amiga_e / peps / pepsmenus.e < prev   
Text File  |  1994-05-02  |  14KB  |  300 lines
  1. DEF save_list[500]:LIST        /* Buffer contenant la description des menus (LONG) */
  2.                                /* ATTENTION une LIST stocke sur des LONG ou INT ou CHAR mais pas sur les 3  */
  3.                                /* la copie dans des structures newmenu se feras plus tard (PROC readfile()) */
  4. DEF com_list[500]:LIST         /* Liste Contenant les commandes associées aux menus */
  5. DEF stack_list[500]:LIST       /* Liste contenant les stacks associées aux commandes */
  6. DEF save_list_chip=NIL,total_chip      /* Emplacement réel des menus,total mémoire de réservé */
  7. PROC p_ReadMenuFile(mfile) /*"p_ReadMenuFile(mfile)"*/
  8. /********************************************************************************
  9.  * Para     : NONE
  10.  * Return   : TRUE si tout c'est bien passé,sion FALSE
  11.  * Descritption : Ouvre le fichier de config et le traite ligne par ligne.
  12.  *******************************************************************************/
  13.   DEF len,a,adr,buf,handle,flen=TRUE,long,pas
  14.   DEF my_string[256]:STRING,p=0,ff[256]:STRING
  15.   DEF my_menu:PTR TO newmenu,test_parsing=NIL
  16.   /*****************************************/
  17.   /* Stockage du fichier source dans buf   */
  18.   /*****************************************/
  19.   IF (flen:=FileLength(mfile))=-1 THEN RETURN FALSE
  20.   IF (buf:=New(flen+1))=NIL THEN RETURN FALSE
  21.   IF (handle:=Open(mfile,1005))=NIL THEN RETURN FALSE
  22.   len:=Read(handle,buf,flen)
  23.   Close(handle)
  24.   IF len<1 THEN RETURN FALSE
  25.   adr:=buf
  26.   /***********/
  27.   /* Lecture */
  28.   /***********/
  29.   FOR a:=0 TO len-1
  30.     test_parsing:=NIL
  31.     IF buf[a]=10                /* Retour chariot (on traite le fichier par ligne) */
  32.     IF a-p<>0               /* si la ligne n'est pas vide ..*/
  33.         StringF(my_string,'\s',adr)     /* stockage de la ligne dans ff */
  34.         ff:=String(EstrLen(my_string))
  35.         StrCopy(ff,my_string,a-p)
  36.         IF (test_parsing:=p_ParseLineMenu(ff))=FALSE  /* parsing de ff */
  37.             Dispose(buf)
  38.             dWriteF(['Error Read Menu File :\s\n'],[ff])
  39.             RETURN FALSE
  40.         ENDIF
  41.     ENDIF
  42.     p:=a+1
  43.     adr:=buf+a+1
  44.     ENDIF
  45.   ENDFOR
  46.   Dispose(buf)                            /* libére la mémoire buffer du fichier_source */
  47.   ListAdd(save_list,[0,0,0,0,0,0,0],7)    /* ajoute le END_MENU (0)  a la liste des menus */
  48.   long:=ListLen(save_list)                /* longueur de la  liste qui sert a calculer */
  49.   total_chip:=(long/7)*20                 /* la place que prennent les structures newmenu */
  50.   save_list_chip:=AllocMem(total_chip,2)  /* on alloue la place néssessaire */
  51.   pas:=save_list_chip
  52.   FOR buf:=0 TO long-1 STEP 7
  53.     my_menu:=New(SIZEOF newmenu)             /* création */
  54.     my_menu.type:=save_list[buf]         /* stockage */
  55.     my_menu.pad:=save_list[buf+1]        /*    "     */
  56.     my_menu.label:=save_list[buf+2]      /*    "     */
  57.     my_menu.commkey:=save_list[buf+3]    /*    "     */
  58.     my_menu.flags:=save_list[buf+4]      /*    "     */
  59.     my_menu.mutualexclude:=save_list[buf+5]  /*    "     */
  60.     my_menu.userdata:=save_list[buf+6]   /*    "     */
  61.     CopyMem(my_menu,pas,20)                  /* Copie en mémoire */
  62.     pas:=pas+20              /* incrémentation par pas de 20 */
  63.     Dispose(my_menu)                         /* libération du buffer my_menu */
  64.   ENDFOR
  65.   /*******************/
  66.   /* FIN DE LA COPIE */
  67.   /*******************/
  68.   Dispose(save_list)   /* libération de buffer */
  69.   RETURN TRUE
  70. ENDPROC
  71. PROC p_ParseLineMenu(ff) /*"p_ParseLineMenu(ff)"*/
  72. /********************************************************************************
  73.  * Para     : Chaine de caractères.
  74.  * Return   : TRUE si tout c'set bien passé,sion FALSE
  75.  * Description  : Stock la ligne dans save_list.
  76.  *******************************************************************************/
  77.     DEF ret_str[256]:STRING
  78.     DEF trim_str[256]:STRING
  79.     DEF parse_str[256]:STRING
  80.     DEF str_para[256]:STRING
  81.     trim_str:=TrimStr(ff)
  82.     IF StrCmp('#',ff,1)<>TRUE                                        /* si ce n'est pas un commentaire.. */
  83.         StrCopy(parse_str,trim_str,ALL)
  84.         IF StrCmp('MENU',parse_str,4)=TRUE                           /* Entrée Menu */
  85.             IF (ret_str:=found_para('MENU',parse_str,'"'))<>FALSE        /* Trouve le titre */
  86.                 str_para:=String(EstrLen(ret_str))
  87.                 StrCopy(str_para,ret_str,ALL)
  88.                 ListAdd(save_list,[1,0,str_para,0,0,0,0],7)          /* stockage dans la liste */
  89.                 ListAdd(com_list,[''],1)                             /* mise a jour des autres listes */
  90.                 ListAdd(stack_list,[''],1)
  91.                 Dispose(str_para)                                    /* libère mem */
  92.             ENDIF
  93.             RETURN TRUE                          /* LIGNE OK */
  94.         ELSEIF StrCmp('BARL',parse_str,4)=TRUE
  95.             ListAdd(save_list,[2,NM_BARLABEL,0,0,0,0,0],7)
  96.             RETURN TRUE
  97.         ELSEIF StrCmp('ITEM',parse_str,4)=TRUE                       /* Entrée Item */
  98.             IF (ret_str:=found_para('ITEM',parse_str,'"'))<>FALSE        /* Trouve le nom */
  99.                 str_para:=String(EstrLen(ret_str))
  100.                 StrCopy(str_para,ret_str,ALL)
  101.                 ListAdd(save_list,[2,0,str_para],3)                  /* stockage dans la liste */
  102.                 Dispose(str_para)
  103.                 IF (ret_str:=found_para('KEY',parse_str,'"'))<>FALSE     /* Trouve le raccourci clavier */
  104.                     str_para:=String(EstrLen(ret_str))
  105.                     StrCopy(str_para,ret_str,ALL)
  106.                     ListAdd(save_list,[str_para,0,0,0],4)            /* stockage dans la liste */
  107.                     Dispose(str_para)                                /* libère la mémoire */
  108.                 ELSE
  109.                     ListAdd(save_list,[0,0,0,0],4)                   /* pas de raccourci clavier */
  110.                 ENDIF
  111.                 IF (ret_str:=found_para('COMM',parse_str,'"'))<>FALSE    /* trouve la commande associée */
  112.                     str_para:=String(EstrLen(ret_str))
  113.                     StrCopy(str_para,ret_str,ALL)
  114.                     ListAdd(com_list,[str_para],1)                   /* stockage dans la liste */
  115.                     Dispose(str_para)
  116.                 ELSE
  117.                     ListAdd(com_list,[''],1)                         /* item sans commande,donc c'est un item */
  118.                 ENDIF                            /* avec subitem                  */
  119.                 IF (ret_str:=found_para('TYPE',parse_str,'"'))<>FALSE   /* trouve la stack */
  120.                     str_para:=String(EstrLen(ret_str))
  121.                     StrCopy(str_para,ret_str,ALL)
  122.                     ListAdd(stack_list,[str_para],1)                 /* stockage dans la liste */
  123.                     Dispose(str_para)
  124.                 ELSE
  125.                     ListAdd(stack_list,['REXX'],1)                   /* stack par défault a 4000 */
  126.                 ENDIF
  127.             ENDIF
  128.             RETURN TRUE                          /* LIGNE OK */
  129.         ELSEIF StrCmp('SUBI',parse_str,4)=TRUE                       /* Entrée SubItem */
  130.             IF (ret_str:=found_para('SUBI',parse_str,'"'))<>FALSE        /* Trouve le nom */
  131.                 str_para:=String(EstrLen(ret_str))
  132.                 StrCopy(str_para,ret_str,ALL)
  133.                 ListAdd(save_list,[3,0,str_para],3)                  /* Stockage */
  134.                 Dispose(str_para)                                    /* FreeMem  */
  135.                 IF (ret_str:=found_para('KEY',parse_str,'"'))<>FALSE     /* Raccourci clavier */
  136.                     str_para:=String(EstrLen(ret_str))
  137.                     StrCopy(str_para,ret_str,ALL)
  138.                     ListAdd(save_list,[str_para,0,0,0],4)            /* stockage */
  139.                     Dispose(str_para)
  140.                 ELSE
  141.                     ListAdd(save_list,[0,0,0,0],4)                   /* pas de raccourci clavier */
  142.                 ENDIF
  143.                 IF (ret_str:=found_para('COMM',parse_str,'"'))<>FALSE    /* Trouve commande associée */
  144.                     str_para:=String(EstrLen(ret_str))
  145.                     StrCopy(str_para,ret_str,ALL)
  146.                     ListAdd(com_list,[str_para],1)                   /* stockage */
  147.                     Dispose(str_para)
  148.                 ELSE
  149.                     ListAdd(com_list,[''],1)                         /* pas de commande */
  150.                 ENDIF
  151.                 IF (ret_str:=found_para('TYPE',parse_str,'"'))<>FALSE   /* Trouve la stack */
  152.                     str_para:=String(EstrLen(ret_str))
  153.                     StrCopy(str_para,ret_str,ALL)
  154.                     ListAdd(stack_list,[str_para],1)                 /* Stockage */
  155.                     Dispose(str_para)
  156.                 ELSE
  157.                     ListAdd(stack_list,['REXX'],1)                   /* Stack par défault de 4000 */
  158.                 ENDIF
  159.             ENDIF
  160.             RETURN TRUE                          /* LIGNE OK */
  161.         ENDIF
  162.     ELSE
  163.         RETURN TRUE                          /* LIGNE COMMENTAIRE OK */
  164.     ENDIF
  165.     RETURN FALSE                             /* PROBLEME AUCUN #,MENU,ITEM,SUBI DANS CETTE LIGNE */
  166. ENDPROC
  167. PROC p_RemakeMenuList() /*"p_RemakeMenuList()"*/
  168. /********************************************************************************
  169.  * Para     : NONE
  170.  * Return   : NONE
  171.  * Description  : Erreur dans le fichier de config,on ne reconstruit que les
  172.  *        menus par défaut.
  173.  *******************************************************************************/
  174.     DEF my_menu:PTR TO newmenu
  175.     DEF pas,long,buf
  176.     EasyRequestArgs(0,[20,0,0,'Error Found in config. file','Ok'],0,NIL)
  177.     /******************/
  178.     /* On efface tout */
  179.     /******************/
  180.     IF save_list THEN Dispose(save_list)
  181.     IF com_list THEN Dispose(com_list)
  182.     IF stack_list THEN Dispose(stack_list)
  183.     /*******************************************/
  184.     /* Et on initialise que les menus internes */
  185.     /*******************************************/
  186.     ListCopy(save_list,[1,0,'NasGûl Menus',0,0,0,0,
  187.               2,0,'  Infos...  ',0,0,0,0,
  188.               2,0,'  NewShell  ',0,0,0,0,
  189.               2,0,'  Rebuild   ',0,0,0,0,
  190.               2,0,'  Quitter   ',0,0,0,0],35)
  191.     ListCopy(com_list,[0,0,0,0,0],5)
  192.     ListCopy(stack_list,[0,0,0,0,0],5)
  193.     ListAdd(save_list,[0,0,0,0,0,0,0],7)
  194.     long:=ListLen(save_list)
  195.     total_chip:=(long/7)*20
  196.     save_list_chip:=AllocMem(total_chip,2)
  197.     pas:=save_list_chip
  198.     FOR buf:=0 TO long-1 STEP 7
  199.       my_menu:=New(SIZEOF newmenu)
  200.       my_menu.type:=save_list[buf]
  201.       my_menu.pad:=save_list[buf+1]
  202.       my_menu.label:=save_list[buf+2]
  203.       my_menu.commkey:=save_list[buf+3]
  204.       my_menu.flags:=save_list[buf+4]
  205.       my_menu.mutualexclude:=save_list[buf+5]
  206.       my_menu.userdata:=save_list[buf+6]
  207.       CopyMem(my_menu,pas,20)
  208.       pas:=pas+20
  209.       Dispose(my_menu)
  210.     ENDFOR
  211.     Dispose(save_list)
  212. ENDPROC
  213. PROC p_RebuildMenu() /*"p_RebuidMenu()"*/
  214. /********************************************************************************
  215.  * Para     : NONE.
  216.  * Return   : ER_NONE si Ok,sinon l'erreur.
  217.  * Description  : Libère la mémoire des menus,ferme la fenêtre,et reload le
  218.  *        fichier de config.
  219.  *******************************************************************************/
  220.     DEF test_cleanup
  221.     /* <<<< CLEANUP >>>> */
  222.     IF save_list_chip THEN FreeMem(save_list_chip,total_chip)
  223.     IF com_list THEN Dispose(com_list)
  224.     IF stack_list THEN Dispose(stack_list)
  225.     IF pp_window THEN ClearMenuStrip(pp_window)
  226.     IF menu THEN FreeMenus(menu)
  227.     /*************************************/
  228.     /* Initialisation des menus internes */
  229.     /*************************************/
  230.     ListCopy(save_list,[1,0,'NasGûl Menus',0,0,0,0,
  231.             2,0,'  Infos...  ',0,0,0,0,
  232.             2,0,'  NewShell  ',0,0,0,0,
  233.             2,0,'  Rebuild   ',0,0,0,0,
  234.             2,0,'  Quitter   ',0,0,0,0],35)
  235.     ListCopy(com_list,[0,0,0,0,0],5)
  236.     ListCopy(stack_list,[0,0,0,0,0],5)
  237.     /* On charge le fichier */
  238.     IF (test_cleanup:=p_ReadMenuFile(menufile))=FALSE THEN p_RemakeMenuList()
  239.     IF (menu:=CreateMenusA(save_list_chip,NIL))=NIL THEN RETURN ER_MENUS
  240.     IF LayoutMenusA(menu,visual,NIL)=FALSE THEN RETURN ER_MENUS
  241.     IF pp_window<>NIL
  242.         IF SetMenuStrip(pp_window,menu)=FALSE THEN RETURN ER_MENUS
  243.     ENDIF
  244.     Gt_RefreshWindow(pp_window,NIL)
  245.     RETURN ER_NONE
  246. ENDPROC
  247. PROC p_ExecuteMenu(ms,adr_menu) /*"p_ExecuteMenu(ms,adr_menu)"*/
  248. /********************************************************************************
  249.  * Para     : adr menustrip,adr item
  250.  * Return   : NONE
  251.  * Description  : Compte les menus et execute la commande associée
  252.  *******************************************************************************/
  253.     DEF look_menu:PTR TO menu
  254.     DEF look_item:PTR TO menuitem
  255.     DEF look_subitem:PTR TO menuitem
  256.     DEF look_itext:PTR TO intuitext
  257.     DEF adr
  258.     DEF count=0
  259.     DEF exe_str[256]:STRING,type_exe[256]:STRING
  260.     look_menu:=ms
  261.     adr:=adr_menu
  262.     WHILE look_menu
  263.     IF look_menu.firstitem<>0
  264.         look_item:=look_menu.firstitem
  265.         count:=count+1
  266.         WHILE look_item
  267.         IF look_item=adr
  268.             JUMP found_exec
  269.         ENDIF
  270.         count:=count+1
  271.         look_itext:=look_item.itemfill         /* Structure Intuitext (texte du menu) */
  272.         IF look_item.subitem<>0
  273.             look_subitem:=look_item.subitem
  274.             WHILE look_subitem
  275.             IF look_subitem=adr
  276.                 JUMP found_exec
  277.             ENDIF
  278.             count:=count+1
  279.             look_itext:=look_subitem.itemfill
  280.             look_subitem:=look_subitem.nextitem
  281.             ENDWHILE
  282.         ENDIF
  283.         look_item:=look_item.nextitem
  284.         ENDWHILE
  285.     ENDIF
  286.     look_menu:=look_menu.nextmenu
  287.     ENDWHILE
  288.     found_exec:
  289.     StrCopy(exe_str,com_list[count],ALL)
  290.     StrCopy(type_exe,stack_list[count],ALL)
  291.     IF StrCmp(type_exe,'CLI',4)
  292.         p_Execute(exe_str)
  293.     ELSEIF StrCmp(type_exe,'REXX',4)
  294.         p_SendRexxCommand(exe_str,'REXX',RXCOMM+RXFF_RESULT)
  295.     ELSEIF StrCmp(type_exe,'EDPORT',6)
  296.         p_SendRexxCommand(exe_str,edarexxportname,RXCOMM+RXFF_RESULT)
  297.     ENDIF
  298. ENDPROC
  299.  
  300.